/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package manager.auxiliares;

import java.sql.ResultSet;
import java.sql.Statement;
import java.sql.Timestamp;
import java.text.NumberFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Formatter;
import java.util.LinkedList;
import java.util.Locale;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.swing.text.DefaultFormatterFactory;
import javax.swing.text.MaskFormatter;
import javax.swing.text.NumberFormatter;
import manager.principal.fonte.JanelaLogin;
import manager.principal.dao.EstadoDao;
import manager.principal.dao.ProfissaoDao;

/**
 *
 * @author Thiago
 */
public class Format {

    /**
     * ****Padrão de Data********
     */
    public static Timestamp getCurrentDatabseTimeStamp() {
        Timestamp data = new Timestamp(00 - 00 - 00);
        try {
            Statement stm = JanelaLogin.getConnection().createStatement();
            ResultSet rs = stm.executeQuery("SELECT CURRENT_TIMESTAMP();");
            if (rs.first()) {
                data = rs.getTimestamp(1);
            }
            rs.close();
            stm.close();
        } catch (Exception e) {
        }
        return data;
    }

    /**
     * Retorna a data atual no formato DD/MM/AAAA
     *
     * @return Data atual no formato DD/MM/AAAA
     */
    public static String getCurrentVisualDate() {
        return formatarTimeStampApresentacao(getCurrentDatabseTimeStamp());
    }

    public static String formatarTimeStampApresentacao(Timestamp timestamp) {
        Date date = new Date(timestamp.getTime());
        SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
        return formatador.format(date);
    }

    public static String formatTimeStampToCompleteDatetime(Timestamp timestamp) {
        Date date = new Date(timestamp.getTime());
        SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy HH:mm");
        return formatador.format(date);
    }

    public static Timestamp formatVisualDateToTimestamp(String date) {
        Date newDate = new Date(getCurrentDatabseTimeStamp().getTime());
        String[] dateParams = date.split("/");
        newDate.setDate(Integer.parseInt(dateParams[0]));
        newDate.setMonth(Integer.parseInt(dateParams[1]) - 1);
        newDate.setYear(Integer.parseInt(dateParams[2]) - 1900);

        Timestamp timestamp = new Timestamp(newDate.getTime());
        return timestamp;
    }

    /**
     * *******Validação de formatos***********
     */
    public static String formatarInterioPontos(String num) {
        Formatter formatter = new Formatter();
        String str = formatter.format("%,d", Integer.parseInt(num)).toString();
        return str;
    }

    public static String formatarMonetario(String numero) {
        NumberFormat nf = NumberFormat.getCurrencyInstance(new Locale("pt", "BR"));
        double d = Double.parseDouble(numero);
        String s = nf.format(d);
        return s;
    }

    public static Double formatarStringDouble(String numero) {
        numero = numero.replaceAll(",", ".");
        double numeroFormatado = Double.parseDouble(numero);
        return truncarDoubleDoisDigitos(numeroFormatado);
    }

    /**
     * Retorna expressão lógica de validação de data
     *
     * @return String com a expressão regular que valida uma data
     */
    public static String getDatePattern() {
        String DatePattern = "^(?:(31)(\\D)(0?[13578]|1[02])\\2|(29|30)(\\D)(0?[13-9]|1[0-2])\\5|(0?[1-9]|1\\d|2[0-8])(\\D)(0?[1-9]|1[0-2])\\8)((?:1[6-9]|[2-9]\\d)?\\d{2})$|^(29)(\\D)(0?2)\\12((?:1[6-9]|[2-9]\\d)?(?:0[48]|[2468][048]|[13579][26])|(?:16|[2468][048]|[3579][26])00)$";
        return DatePattern;
    }

    /**
     * Verifica se determinado cnpj é valido. ex: 02998301000181
     *
     * @param strCnpj CNPJ que será validado
     * @return True em caso positivo, false caso contrário
     */
    static public boolean isCNPJ(String strCnpj) {
        strCnpj = strCnpj.replaceAll("-", "");
        strCnpj = strCnpj.replaceAll("\\.", "");
        strCnpj = strCnpj.replaceAll(" ", "");
        strCnpj = strCnpj.replaceAll("/", "");
        if (strCnpj.length() < 14) {
            return false;
        } else {
            int soma = 0, aux, dig;
            String cnpj_calc = strCnpj.substring(0, 12);

            if (strCnpj.length() != 14) {
                return false;
            }

            char[] chr_cnpj = strCnpj.toCharArray();

            /*
             * Primeira parte
             */
            for (int i = 0; i < 4; i++) {
                if (chr_cnpj[i] - 48 >= 0 && chr_cnpj[i] - 48 <= 9) {
                    soma += (chr_cnpj[i] - 48) * (6 - (i + 1));
                }
            }
            for (int i = 0; i < 8; i++) {
                if (chr_cnpj[i + 4] - 48 >= 0 && chr_cnpj[i + 4] - 48 <= 9) {
                    soma += (chr_cnpj[i + 4] - 48) * (10 - (i + 1));
                }
            }
            dig = 11 - (soma % 11);

            cnpj_calc += (dig == 10 || dig == 11)
                    ? "0" : Integer.toString(dig);

            /*
             * Segunda parte
             */
            soma = 0;
            for (int i = 0; i < 5; i++) {
                if (chr_cnpj[i] - 48 >= 0 && chr_cnpj[i] - 48 <= 9) {
                    soma += (chr_cnpj[i] - 48) * (7 - (i + 1));
                }
            }
            for (int i = 0; i < 8; i++) {
                if (chr_cnpj[i + 5] - 48 >= 0 && chr_cnpj[i + 5] - 48 <= 9) {
                    soma += (chr_cnpj[i + 5] - 48) * (10 - (i + 1));
                }
            }
            dig = 11 - (soma % 11);
            cnpj_calc += (dig == 10 || dig == 11)
                    ? "0" : Integer.toString(dig);

            return strCnpj.equals(cnpj_calc);
        }
    }

    /**
     * Verifica se um cpf é válido. Ex : 111.111.111-09
     *
     * @param strCpf Cpf que será validado
     * @return True em caso positivo, false caso contrário
     */
    public static boolean isCPF(String strCpf) {
        strCpf = strCpf.replaceAll("-", "");
        strCpf = strCpf.replaceAll("\\.", "");
        strCpf = strCpf.replaceAll(" ", "");
        if (strCpf.length() < 11) {
            return false;
        } else {
            int d1, d2;
            int digito1, digito2, resto;
            int digitoCPF;
            String nDigResult;

            d1 = d2 = 0;
            digito1 = digito2 = resto = 0;

            for (int nCount = 1; nCount < strCpf.length() - 1; nCount++) {
                digitoCPF = Integer.valueOf(strCpf.substring(nCount - 1, nCount)).intValue();
                //multiplique a ultima casa por 2 a seguinte por 3 a seguinte por 4 e assim por diante.
                d1 = d1 + (11 - nCount) * digitoCPF;
                //para o segundo digito repita o procedimento incluindo o primeiro digito calculado no passo anterior.
                d2 = d2 + (12 - nCount) * digitoCPF;
            }
            ;
            //Primeiro resto da divisão por 11.
            resto = (d1 % 11);
            //Se o resultado for 0 ou 1 o digito é 0 caso contrário o digito é 11 menos o resultado anterior.
            if (resto < 2) {
                digito1 = 0;
            } else {
                digito1 = 11 - resto;
            }
            d2 += 2 * digito1;
            //Segundo resto da divisão por 11.
            resto = (d2 % 11);
            //Se o resultado for 0 ou 1 o digito é 0 caso contrário o digito é 11 menos o resultado anterior.
            if (resto < 2) {
                digito2 = 0;
            } else {
                digito2 = 11 - resto;
            }
            //Digito verificador do CPF que está sendo validado.
            String nDigVerific = strCpf.substring(strCpf.length() - 2, strCpf.length());
            //Concatenando o primeiro resto com o segundo.
            nDigResult = String.valueOf(digito1) + String.valueOf(digito2);
            //comparar o digito verificador do cpf com o primeiro resto + o segundo resto.
            return nDigVerific.equals(nDigResult);
        }
    }

    //Funcao para validar Numeros inteiros
    public static boolean isInteger(String source) {
        try {
            if (source.length() != 0) {
                // Obtém a expressão regular
                String regex = "\\D";
                Pattern pattern = Pattern.compile(regex);
                Matcher matcher = pattern.matcher(source);
                // Mostra as similaridades
                if (matcher.find()) {
                    return false;
                } else {
                    return true;
                }
            } else {
                return false;
            }
        } catch (Exception e) {
            System.out.println("Error");
        }

        return false;
    }

    public static LinkedList<Boolean> getBooleanLinkedList(int size) {
        LinkedList<Boolean> booleanList = new LinkedList<Boolean>();
        for (int i = 0; i < size; i++) {
            booleanList.add(false);
        }
        return booleanList;
    }

    //Funcao para validar Numeros double
    public static boolean isDouble(String source) {
        try {
            if (source.length() != 0) {
                source = source.replaceAll(",", ".");
                source = source.concat("0");
                String[] contagem = source.split("\\.");
                if (contagem.length <= 2) {
                    // Obtém a expressão regular
                    source = source.replaceAll("\\.", "");
                    String regex = "\\D";
                    Pattern pattern = Pattern.compile(regex);
                    Matcher matcher = pattern.matcher(source);
                    // Mostra as similaridades
                    if (matcher.find()) {
                        return false;
                    } else {
                        return true;
                    }
                } else {
                    return false;
                }
            } else {
                return false;
            }
        } catch (Exception e) {
            System.out.println("Error");
        }

        return false;
    }

    public static Double truncarDouble(double val, int p) {
        String str = Double.toString(val) + "00";
        str = str.substring(0, str.indexOf(".") + p + 1);
        val = Double.parseDouble(str);
        return val;
    }

    public static Double truncarDoubleDoisDigitos(double val) {
        int p = 2;
        String str = Double.toString(val) + "00";
        str = str.substring(0, str.indexOf(".") + p + 1);
        val = Double.parseDouble(str);
        return val;
    }

    //Funcao para setar o jComboBox uf de algum panel
    public static void formatarComboBoxUf(javax.swing.JComboBox comboBoxUf, String estadoSelecionado) {
        try {
            comboBoxUf.removeAllItems();
            LinkedList<String> estados = new EstadoDao().buscar("Nome", "%", false);
            for (int i = 0; i < estados.size(); i++) {
                comboBoxUf.addItem(estados.get(i));
            }
            if (!estadoSelecionado.equals("")) {
                comboBoxUf.setSelectedItem(estadoSelecionado);
            }
        } catch (Exception e) {
            MensagemExcessao.mostrarMensagem(e, "Buscando Estados");
        }
    }

    //Funcao para setar o jComboBox Profissao de algum panel
    public static void formatarComboBoxProfissao(javax.swing.JComboBox comboBoxProfissao, String profissaoSelecionada) {
        try {
            comboBoxProfissao.removeAllItems();
            LinkedList<String> profissoes = new ProfissaoDao().buscar("Nome", "%", false);
            for (int i = 0; i < profissoes.size(); i++) {
                comboBoxProfissao.addItem(profissoes.get(i));
            }
            if (!profissaoSelecionada.equals("")) {
                comboBoxProfissao.setSelectedItem(profissaoSelecionada);
            }
        } catch (Exception e) {
            MensagemExcessao.mostrarMensagem(e, "Buscando Profissões");
        }
    }

    //Funcao para formatar ddd
    public static String formatarDddBanco(String ddd) {
        ddd = ddd.replace("(", "");
        ddd = ddd.replace(")", "");
        return ddd;
    }
    //Funcao para formatar cnpj

    public static String formatCnpjToDatabase(String cnpj) {
        cnpj = cnpj.replace(".", "");
        cnpj = cnpj.replace("/", "");
        cnpj = cnpj.replace("-", "");
        return cnpj;
    }
    //Funcao para formatar cpf

    public static String formatCpfToDatabase(String cpf) {
        cpf = cpf.replace(".", "");
        cpf = cpf.replace("-", "");
        return cpf;
    }

    //Funcao para formatar ddd
    public static String formatarBancoDDD(String ddd) {
        return "(" + ddd + ")";
    }

    //Funcao para formatar cnpj
    public static String formatarBancoCnpj(String cnpj) {
        String result = new String();
        if (cnpj.length() == 14) {
            result = result.concat(cnpj.substring(0, 2) + ".");
            result = result.concat(cnpj.substring(2, 5) + ".");
            result = result.concat(cnpj.substring(5, 8) + "/");
            result = result.concat(cnpj.substring(8, 12) + "-");
            result = result.concat(cnpj.substring(12, 14));
            return result;
        } else {
            return cnpj;
        }
    }
    //Funcao para formatar cpf

    public static String formatarBancoCpf(String cpf) {
        String result = new String();
        if (cpf.length() == 11) {
            result = result.concat(cpf.substring(0, 3) + ".");
            result = result.concat(cpf.substring(3, 6) + ".");
            result = result.concat(cpf.substring(6, 9) + "-");
            result = result.concat(cpf.substring(9, 11));
            return result;
        } else {
            return cpf;
        }
    }
    //Funcao para setar o formato de algum formatted textField com o formato de cep

    public static DefaultFormatterFactory setFormatoCep() {
        MaskFormatter mask = null;

        try {
            mask = new MaskFormatter("#####-###");
        } catch (ParseException pe) {
        }
        DefaultFormatterFactory factory = new DefaultFormatterFactory(mask, mask);
        return factory;
    }

    //Funcao para setar o formato de algum formatted textField com o formato de dd
    public static DefaultFormatterFactory setFormatoDdd() {
        MaskFormatter mask = null;
        try {
            mask = new MaskFormatter("(##)");
        } catch (ParseException pe) {
        }
        DefaultFormatterFactory factory = new DefaultFormatterFactory(mask, mask);
        return factory;
    }

    public static DefaultFormatterFactory getDateFormat() {
        MaskFormatter mask = null;

        try {
            mask = new MaskFormatter("##/##/####");
        } catch (ParseException pe) {
        }
        DefaultFormatterFactory factory = new DefaultFormatterFactory(mask, mask);
        return factory;
    }

    public static DefaultFormatterFactory setFormatoDia() {
        MaskFormatter mask = null;

        try {
            mask = new MaskFormatter("##");
        } catch (ParseException pe) {
        }
        DefaultFormatterFactory factory = new DefaultFormatterFactory(mask, mask);
        return factory;
    }

    public static DefaultFormatterFactory getCnpjFormat() {
        MaskFormatter mask = null;

        try {
            mask = new MaskFormatter("##.###.###/####-##");
        } catch (ParseException pe) {
        }
        DefaultFormatterFactory factory = new DefaultFormatterFactory(mask, mask);
        return factory;
    }

    public static DefaultFormatterFactory getCpfFormat() {
        MaskFormatter mask = null;

        try {
            mask = new MaskFormatter("###.###.###-##");
        } catch (ParseException pe) {
        }
        DefaultFormatterFactory factory = new DefaultFormatterFactory(mask, mask);
        return factory;
    }

    public static DefaultFormatterFactory getMonataryFormat() {
        NumberFormat amountDisplayFormat;
        NumberFormat amountEditFormat;
        amountDisplayFormat = NumberFormat.getCurrencyInstance();
        amountDisplayFormat.setMinimumFractionDigits(2);
        amountEditFormat = NumberFormat.getNumberInstance();
        DefaultFormatterFactory defaultFormatterFactory = new DefaultFormatterFactory(
                new NumberFormatter(amountDisplayFormat), new NumberFormatter(
                amountDisplayFormat), new NumberFormatter(amountEditFormat));
        return defaultFormatterFactory;
    }
}
